package stream.method;

import com.sun.deploy.panel.JreFindDialog;
import stream.StreamsLearn;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

/**
 * @CreateBy zhangdingyi
 * @Date 2022-10-05
 * @Content 这个是流的方法 filter 过滤器,map 以某种方式来 转换list中的数值，
 */
public class one {
    static List<String> list = new ArrayList();

    static {
        System.out.println("静态 -加载数据！");
        //10
        list.add("zxcasdqwer");
        //5
        list.add("zxcas");
        //3
        list.add("zxc");
        System.out.println("静态 -加载数据成功！");
    }

    public static void main(String[] args) {
        //过滤器 -过滤并生成新的流
        testFilter();
        //转换数据 -把数据中的内容都转换成 大写字母
        //testMap();
        //flatMap 的使用
        //testFlatMap();

    }

    /**
     * 过滤器的使用
     * 这个使用时，一般都会产生新的 流 ，过滤掉 A 还剩 B 把 B 的数据用新的流来装载
     *
     * 产生一个流，它包含当前流中所有满足断言条件的元素
     */
    static void testFilter() {
        //这个实质就是 把 list 先转换成流（list.stream()） 再 通过 过滤器 过滤掉数据生成新的 流（stream）
        Stream<String> stream = list.stream().filter(dome -> dome.length() >= 5);
        StreamsLearn.show("stream", stream);
    }

    /**
     * 这里是遍历 流 中的所有元素并转换
     *
     * 产生一个流，它包含将mapper应用于当前流中所有元素所产生的结果。
     */
    static void testMap() {
        //这个实质就是 把 list 先转换成流（list.stream()） 再 通过 过滤器 过滤掉数据生成新的 流（stream）
        Stream<String> map = list.stream().map(String::toUpperCase);
        StreamsLearn.show("map", map);

        //这里是截取 对应的字符串 并显示出来
        Stream<String> mapSub = list.stream().map(s -> s.substring(0, 2));
        StreamsLearn.show("mapSub", mapSub);
    }

    /**
     * flatMap 方法是解析 Stream<String> 并直接获取到 流数组的值
     * 简单的说这个方法就是读取 流 并 整理成新的一个 流 是 Stream<String> 纯粹的流
     * 而不是  Stream<Stream<String>>  类型中掺杂着其他类型的流
     * 整理：
     * 原： 流泛型（<<T>>模式）
     * 处理后：这里处理的是 把 流泛型（<<T>>模式） 整理成 新的一个 流泛型（<T>模式）
     *
     * 产生一个流，它是通过将mapper应用于当前流中所有元素所产生的结果连接到一起而获得的。
     */
    static void testFlatMap() {
        //这里是截取 对应的字符串 并显示出来
        //第一个会报错 使用数据返回结果之后，会让 该map 得到一个 Stream<String>  因而不能直接解析
        //Stream<String> stream1 = list.stream().map(s -> letters(s));
        //需要如此，才能够解析
        //one 这边是直接输出地址
        Stream<Stream<String>> flatMapOne = list.stream().map(s -> letters(s));
        StreamsLearn.show("flatMap one -> ", flatMapOne);

        //如果是 直接按照 第一种写法，就需要改用方法来进行输出
        //然后直接使用 flatMap 方法就把其中返回的 流集合 直接给 整理 并输出 对应 的值
        Stream<String> flatMap = list.stream().flatMap(s -> letters(s));
        StreamsLearn.show("flatMap -> ", flatMap);

    }

    /**
     * 这个方法是 把一个字符串 变成 一个个字母
     *
     * @param s 传入字符串
     * @return 返回 流
     */
   public static Stream<String> letters(String s) {
        List<String> result = new ArrayList<>();
        // 这里对数据进行 分割，字符串拆分成独立的个体
        for (int i = 0; i < s.length(); i++)
            result.add(s.substring(i, i + 1));
        return result.stream();
    }


}
